package br.com.aspas.beans;

import br.com.aspas.modelo.CursosEvento;
import br.com.aspas.modelo.CursosPessoaFisica;
import br.com.aspas.modelo.CursosPessoaFisicaPK;
import br.com.aspas.modelo.AtividadeInscricao;
import br.com.aspas.modelo.Caixa;
import br.com.aspas.modelo.Categoria;
import br.com.aspas.modelo.Cidade;
import br.com.aspas.modelo.Estado;
import br.com.aspas.modelo.Etiqueta;
import br.com.aspas.modelo.Evento;
import br.com.aspas.modelo.PessoaFisica;
import br.com.aspas.modelo.PessoaFisicaJuridicaEvento;
import br.com.aspas.modelo.PessoaFisicaJuridicaEventoPK;
import br.com.aspas.modelo.PessoaJuridica;
import br.com.aspas.modelo.Recebimentos;
import br.com.aspas.modelo.TipoInscricao;
import br.com.aspas.modelo.UsuarioImpressora;
import br.com.aspas.modelo.ValidadeInscricao;
import br.com.aspas.modelo.usuario.Usuario;
import br.com.aspas.modelo.usuario.UsuarioEventoPerfil;
import br.com.aspas.persistencia.AtividadeInscricaoDao;
import br.com.aspas.persistencia.CaixaDao;
import br.com.aspas.persistencia.CategoriaDao;
import br.com.aspas.persistencia.CidadeDao;
import br.com.aspas.persistencia.CursoDao;
import br.com.aspas.persistencia.CursosPessoaFisicaDao;
import br.com.aspas.persistencia.EstadoDao;
import br.com.aspas.persistencia.EtiquetaDao;
import br.com.aspas.persistencia.PessoaFisicaDao;
import br.com.aspas.persistencia.PessoaFisicaJuridicaEventoDao;
import br.com.aspas.persistencia.PessoaJuridicaDao;
import br.com.aspas.persistencia.RecebimentosDao;
import br.com.aspas.persistencia.TipoEtiquetaDao;
import br.com.aspas.persistencia.TipoInscricaoDao;
import br.com.aspas.persistencia.UsuarioImpressoraDao;
import br.com.aspas.persistencia.ValidadeInscricaoDao;
import br.com.aspas.persistencia.usuario.UsuarioDao;
import br.com.aspas.persistencia.usuario.UsuarioEventoPerfilDao;
import br.com.aspas.util.Imprimir;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.faces.application.FacesMessage;
import javax.faces.context.FacesContext;
import javax.faces.model.SelectItem;

public class PessoaPFBean {

    private Boolean solicitaAutorizacao;
    private UsuarioEventoPerfilDao usuarioEventoPerfilDao;
    private UsuarioDao usuarioDao;
    private boolean autorizacaoCortesia;
    private String senhaCortesia;
    private CaixaDao caixaDao;
    private Caixa caixa;
    private boolean bloqueado;
    private List<PessoaFisicaJuridicaEvento> pfje;
    private PessoaFisicaJuridicaEvento pessoaFisicaJuridica;
    private String autorizador;
    private PessoaJuridica pessoaJuridica;
    private PessoaJuridicaDao pessoaJuridicaDao;
    private PessoaFisica pessoaFisica;
    private Integer codEstado;
    private Integer codCidade;
    private List<SelectItem> estados;
    private List<SelectItem> cidades;
    private List<PessoaFisica> listarPessoaFisica;
    private List<SelectItem> listarCategorias;
    private List<SelectItem> listarTipoInscricao;
    private List<SelectItem> atividades;
    private Integer codigoPF;
    private String valorBusca;
    private String param;
    private UsuarioEventoPerfil usuarioEventoPerfil;
    private Integer codCategoria;
    private Integer codEvento;
    private CategoriaDao categoriaDao;
    private TipoInscricaoDao tipoInscricaoDao;
    private EstadoDao estadoDao;
    private CidadeDao cidadeDao;
    private PessoaFisicaDao pessoaFisicaDao;
    private UsuarioImpressoraDao usuarioImpressoraDao;
    private EtiquetaDao etiquetaDao;
    private Integer codigoTipoInscricao;
    private AtividadeInscricaoDao atividadeInscricaoDao;
    private ValidadeInscricaoDao validadeInscricaoDao;
    private PessoaFisicaJuridicaEventoDao pessoaFisicaJuridicaEventoDao;
    private Integer codigoAtividade;
    private Integer codigoValidadeAtividade;
    private Boolean autorizado;
    private CursosPessoaFisica cursosPessoaFisica;
    private CursosPessoaFisicaDao cursosPessoaFisicaDao;
    private Boolean editCurso;
    private TipoEtiquetaDao tipoEtiquetaDao;
    private CursoDao cursoDao;
    private String[] listaStringI;
    private String[] listaStringII;
    private List<SelectItem> listarCursosI;
    private List<SelectItem> listarCursosII;
    private List<CursosPessoaFisica> listaCursoPessoaFisicaI;
    private List<CursosPessoaFisica> listaCursoPessoaFisicaII;
    private Recebimentos recebimentos;
    private RecebimentosDao recebimentosDao;
    private Boolean habilitaPagamento;
    private ValidadeInscricao validadeInscricao;
    private String usuarioCortesia;
    private Usuario usuarioAutorizador;
    private Integer numeroParticipacoes;

    public PessoaPFBean() {
        solicitaAutorizacao = true;
        usuarioEventoPerfilDao = new UsuarioEventoPerfilDao();
        usuarioDao = new UsuarioDao();
        caixaDao = new CaixaDao();
        caixa = new Caixa();
        pfje = new ArrayList<PessoaFisicaJuridicaEvento>();
        validadeInscricao = new ValidadeInscricao();
        habilitaPagamento = new Boolean(true);
        pessoaFisica = new PessoaFisica();
        cursosPessoaFisica = new CursosPessoaFisica();
        cursosPessoaFisicaDao = new CursosPessoaFisicaDao();
        cursoDao = new CursoDao();
        cidades = new ArrayList<SelectItem>();
        listarCategorias = new ArrayList<SelectItem>();
        usuarioEventoPerfil = new UsuarioEventoPerfil();
        atividadeInscricaoDao = new AtividadeInscricaoDao();
        pessoaFisicaJuridicaEventoDao = new PessoaFisicaJuridicaEventoDao();
        validadeInscricaoDao = new ValidadeInscricaoDao();
        categoriaDao = new CategoriaDao();
        estadoDao = new EstadoDao();
        cidadeDao = new CidadeDao();
        pessoaFisicaDao = new PessoaFisicaDao();
        usuarioImpressoraDao = new UsuarioImpressoraDao();
        etiquetaDao = new EtiquetaDao();
        tipoInscricaoDao = new TipoInscricaoDao();
        listaCursoPessoaFisicaI = new ArrayList<CursosPessoaFisica>();
        listaCursoPessoaFisicaII = new ArrayList<CursosPessoaFisica>();
        tipoEtiquetaDao = new TipoEtiquetaDao();
        recebimentosDao = new RecebimentosDao();
        pessoaJuridica = new PessoaJuridica();
        pessoaJuridicaDao = new PessoaJuridicaDao();
        editCurso = new Boolean(false);
        pessoaFisicaJuridica = new PessoaFisicaJuridicaEvento();
        bloqueado = true;
        autorizacaoCortesia = false;

    }

    public Integer getNumeroParticipacoes() {
        return numeroParticipacoes;
    }

    public void setNumeroParticipacoes(Integer numeroParticipacoes) {
        this.numeroParticipacoes = numeroParticipacoes;
    }

    public String getAutorizador() {
        return autorizador;
    }

    public void setAutorizador(String autorizador) {
        this.autorizador = autorizador;
    }

    public List<PessoaFisicaJuridicaEvento> getPfje() {
        return pfje;
    }

    public PessoaFisicaJuridicaEvento getPessoaFisicaJuridica() {
        return pessoaFisicaJuridica;
    }

    public Boolean getSolicitaAutorizacao() {
        return solicitaAutorizacao;
    }

    public void setSolicitaAutorizacao(Boolean solicitaAutorizacao) {
        this.solicitaAutorizacao = solicitaAutorizacao;
    }

    public void setPessoaFisicaJuridica(PessoaFisicaJuridicaEvento pessoaFisicaJuridica) {
        this.pessoaFisicaJuridica = pessoaFisicaJuridica;
    }

    public void setPfje(List<PessoaFisicaJuridicaEvento> pfje) {
        this.pfje = pfje;
    }

    public Boolean getHabilitaPagamento() {
        return habilitaPagamento;
    }

    public void setHabilitaPagamento(Boolean habilitaPagamento) {
        this.habilitaPagamento = habilitaPagamento;
    }

    public Boolean getAutorizado() {
        return autorizado;
    }

    public PessoaJuridica getPessoaJuridica() {
        return pessoaJuridica;
    }

    public void setPessoaJuridica(PessoaJuridica pessoaJuridica) {
        this.pessoaJuridica = pessoaJuridica;
    }

    public void setAutorizado(Boolean autorizado) {
        this.autorizado = autorizado;
    }

    public Integer getCodEvento() {
        return codEvento;
    }

    public void setCodEvento(Integer codEvento) {
        this.codEvento = codEvento;
    }

    public ValidadeInscricao getValidadeInscricao() {
        return validadeInscricao;
    }

    public void setValidadeInscricao(ValidadeInscricao validadeInscricao) {
        this.validadeInscricao = validadeInscricao;
    }

    public List<SelectItem> getListarCursosI() {
        carregarCursos();
        return listarCursosI;
    }

    public void setListarCursosI(List<SelectItem> listarCursosI) {
        this.listarCursosI = listarCursosI;
    }

    public List<SelectItem> getListarCursosII() {

        return listarCursosII;
    }

    public void setListarCursosII(List<SelectItem> listarCursosII) {
        this.listarCursosII = listarCursosII;
    }

    public Integer getCodCategoria() {
        return codCategoria;
    }

    public void setCodCategoria(Integer codCategoria) {
        this.codCategoria = codCategoria;
    }

    public UsuarioEventoPerfil getUsuarioEventoPerfil() {
        return usuarioEventoPerfil;
    }

    public void setUsuarioEventoPerfil(UsuarioEventoPerfil usuarioEventoPerfil) {
        this.usuarioEventoPerfil = usuarioEventoPerfil;
    }

    public String[] getListaStringI() {
        return listaStringI;
    }

    public void setListaStringI(String[] listaStringI) {
        this.listaStringI = listaStringI;
    }

    public String[] getListaStringII() {
        return listaStringII;
    }

    public void setListaStringII(String[] listaStringII) {
        this.listaStringII = listaStringII;
    }

    public List<CursosPessoaFisica> getListaCursoPessoaFisicaI() {
        return listaCursoPessoaFisicaI;
    }

    public void setListaCursoPessoaFisicaI(List<CursosPessoaFisica> listaCursoPessoaFisicaI) {
        this.listaCursoPessoaFisicaI = listaCursoPessoaFisicaI;
    }

    public List<CursosPessoaFisica> getListaCursoPessoaFisicaII() {
        return listaCursoPessoaFisicaII;
    }

    public void setListaCursoPessoaFisicaII(List<CursosPessoaFisica> listaCursoPessoaFisicaII) {
        this.listaCursoPessoaFisicaII = listaCursoPessoaFisicaII;
    }

    public String getParam() {
        param = "Nome";
        return param;
    }

    public void setParam(String param) {
        this.param = param;
    }

    public PessoaFisica getPessoaFisica() {
        return pessoaFisica;
    }

    public void setPessoaFisica(PessoaFisica pessoaFisica) {
        this.pessoaFisica = pessoaFisica;
    }

    public Integer getCodCidade() {
        return codCidade;
    }

    public void setCodCidade(Integer codCidade) {
        this.codCidade = codCidade;
    }

    public Integer getCodEstado() {
        return codEstado;
    }

    public void setCodEstado(Integer codEstado) {
        this.codEstado = codEstado;
    }

    public List<SelectItem> getCidades() {
        return cidades;
    }

    public void setCidades(List<SelectItem> cidades) {
        this.cidades = cidades;
    }

    public Integer getCodigoPF() {
        return codigoPF;
    }

    public void setCodigoPF(Integer codigoPF) {
        this.codigoPF = codigoPF;
    }

    public String getValorBusca() {
        return valorBusca;
    }

    public void setValorBusca(String valorBusca) {
        this.valorBusca = valorBusca;
    }

    public Integer getCodigoAtividade() {
        return codigoAtividade;
    }

    public void setCodigoAtividade(Integer codigoAtividade) {
        this.codigoAtividade = codigoAtividade;
    }

    public Integer getCodigoValidadeAtividade() {
        return codigoValidadeAtividade;
    }

    public void setCodigoValidadeAtividade(Integer codigoValidadeAtividade) {
        this.codigoValidadeAtividade = codigoValidadeAtividade;
    }

    public List<SelectItem> getAtividades() {
        Login login = (Login) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("Login");
        Evento evento = login.getUsuarioEventoPerfil().getEvento();

        atividades = new ArrayList<SelectItem>();
        List<AtividadeInscricao> listAtividades = atividadeInscricaoDao.findAtividadeInscricao(evento);
        for (Iterator it = listAtividades.iterator(); it.hasNext();) {
            AtividadeInscricao atividadeInscricao = (AtividadeInscricao) it.next();
            SelectItem item = new SelectItem();
            item.setLabel(atividadeInscricao.getCodigo() + " - " + atividadeInscricao.getNome());
            item.setValue(atividadeInscricao.getCodigo());
            atividades.add(item);
        }

        return atividades;
    }

    public void setAtividades(List<SelectItem> atividades) {
        this.atividades = atividades;
    }

    public List<SelectItem> getListarCategorias() {
        listarCategorias = new ArrayList<SelectItem>();
        List<Categoria> lista = categoriaDao.findAllCategoriaPF();
        for (Iterator it = lista.iterator(); it.hasNext();) {
            Categoria categoria = (Categoria) it.next();
            SelectItem item = new SelectItem();
            item.setLabel(categoria.getNome());
            item.setValue(categoria.getCodigo());
            listarCategorias.add(item);
        }
        return listarCategorias;
    }

    public void setListarCategorias(List<SelectItem> listarCategorias) {
        this.listarCategorias = listarCategorias;
    }

    public List<SelectItem> getListarTipoInscricao() {
        listarTipoInscricao = new ArrayList<SelectItem>();
        List<TipoInscricao> lista = tipoInscricaoDao.findAllTipoInscricao();
        for (Iterator it = lista.iterator(); it.hasNext();) {
            TipoInscricao tipoInsc = (TipoInscricao) it.next();
            SelectItem item = new SelectItem();
            item.setLabel(tipoInsc.getNome());
            item.setValue(tipoInsc.getCodigo());
            listarTipoInscricao.add(item);
        }
        return listarTipoInscricao;
    }

    public void setListarTipoInscricao(List<SelectItem> listarTipoInscricao) {
        this.listarTipoInscricao = listarTipoInscricao;
    }

    public List<SelectItem> getEstados() {
        estados = new ArrayList<SelectItem>();
        List<Estado> listEstados = estadoDao.findAllEstado();
        for (Iterator it = listEstados.iterator(); it.hasNext();) {
            Estado estado = (Estado) it.next();
            SelectItem item = new SelectItem();
            item.setLabel(estado.getSigla());
            item.setValue(estado.getCodigo());
            estados.add(item);
        }
        return estados;
    }

    public void setEstados(List<SelectItem> estados) {
        this.estados = estados;
    }

    public String pesqValorAtividade() {
        Login login = (Login) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("Login");
        Evento evento = login.getUsuarioEventoPerfil().getEvento();
        validadeInscricao = validadeInscricaoDao.findValidadeEvento(new Date(), codigoAtividade, evento.getCodigo());
        return null;
    }

    public String inicializarCombo2() {
        cidades = new ArrayList();
        if (codEstado != null) {
            Collection listCidades = cidadeDao.findAllCidade(codEstado);
            for (Iterator it = listCidades.iterator(); it.hasNext();) {
                Cidade cidade = (Cidade) it.next();
                SelectItem item = new SelectItem();
                item.setLabel(cidade.getNome());
                item.setValue(cidade.getCodigo());
                cidades.add(item);
            }
        } else {
        }
        return null;
    }

    public List<PessoaFisica> getListarPessoaFisica() {
        return listarPessoaFisica;
    }

    public void setListarPessoaFisica(List<PessoaFisica> listarPessoaFisica) {
        this.listarPessoaFisica = listarPessoaFisica;
    }

    public Integer getCodigoTipoInscricao() {
        return codigoTipoInscricao;
    }

    public void setCodigoTipoInscricao(Integer codigoTipoInscricao) {
        this.codigoTipoInscricao = codigoTipoInscricao;
    }

    public String pesquisarCursoPessoaFisica() {

        if (pessoaFisica != null) {

            SimpleDateFormat formatI = new SimpleDateFormat("dd/MM/yyyy");
            SimpleDateFormat formatII = new SimpleDateFormat("dd/MM/yyyy");
            String dataI = "12/10/2010";
            String dataII = "13/10/2010";
            Date dataCursoI = null;
            Date dataCursoII = null;
            try {
                dataCursoI = formatI.parse(dataI);
                dataCursoII = formatI.parse(dataII);
            } catch (Exception e) {
                e.printStackTrace();
            }
            if (pessoaFisica.getCodigo() != null) {


                listaCursoPessoaFisicaI = cursosPessoaFisicaDao.findAllCursoPFData(dataCursoI, pessoaFisica.getCodigo());

                if (listaCursoPessoaFisicaI != null) {
                    listaStringI = new String[listaCursoPessoaFisicaI.size()];
                    for (int i = 0; i < listaCursoPessoaFisicaI.size(); i++) {
                        System.out.println("Lista 1:" + listaCursoPessoaFisicaI.get(i).getCursosEvento().getCursos().getCodigo().toString());
                        listaStringI[i] = listaCursoPessoaFisicaI.get(i).getCursosEvento().getCursos().getCodigo().toString();
                    }

                }

                listaCursoPessoaFisicaII = cursosPessoaFisicaDao.findAllCursoPFData(dataCursoII, pessoaFisica.getCodigo());

                if (listaCursoPessoaFisicaII != null) {

                    listaStringII = new String[listaCursoPessoaFisicaII.size()];
                    for (int j = 0; j < listaCursoPessoaFisicaII.size(); j++) {
                        System.out.println("Lista 2:" + listaCursoPessoaFisicaII.get(j).getCursosEvento().getCursos().getCodigo().toString());
                        listaStringII[j] = listaCursoPessoaFisicaII.get(j).getCursosEvento().getCursos().getCodigo().toString();
                    }


                }
            }

        }

        return null;
    }

    public String pesquisaPF() {
        Login login = new Login();
        login = (Login) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("Login");
        Integer codEvento = login.getUsuarioEventoPerfil().getEvento().getCodigo();
        if (valorBusca == null) {
        } else {
            if (param.equals("Nome")) {
                //listarPessoaFisica = pessoaFisicaDao.findAllPessoaFisicaEvento(valorBusca, codEvento);
                pfje = pessoaFisicaJuridicaEventoDao.findAllPessoaFisicaJuridicaEvento(valorBusca, codEvento);
            }
            if (param.equals("RG")) {
                //listarPessoaFisica = pessoaFisicaDao.findRgEvento(valorBusca, codEvento);
                pfje = pessoaFisicaJuridicaEventoDao.findRgEvento(valorBusca, codEvento);

            }
            if (param.equals("CPF")) {
                listarPessoaFisica = pessoaFisicaDao.findPFCpfEvento(valorBusca, codEvento);
                pfje = pessoaFisicaJuridicaEventoDao.findPFCpfEvento(valorBusca, codEvento);

            }
            if (param.equals("Codigo")) {
                //listarPessoaFisica = pessoaFisicaDao.findPFCodigo(Integer.parseInt(valorBusca), codEvento);
                pfje = pessoaFisicaJuridicaEventoDao.findPFCodigo(Integer.parseInt(valorBusca), codEvento);

            }
        }
        return null;
    }

    public String visualizar() {
        pessoaFisica = pessoaFisicaDao.findByPk(codigoPF);
        if (codCategoria != null) {
            codCategoria = pessoaFisica.getCategoria().getCodigo();
        }
        if (pessoaFisica.getTipoInscricao() != null) {
            codigoTipoInscricao = pessoaFisica.getTipoInscricao().getCodigo();
        }
        codEstado = pessoaFisica.getCidade().getEstado().getCodigo();
        codCidade = pessoaFisica.getCidade().getCodigo();
        inicializarCombo2();
        return "visualizaPF";
    }

    public String editar() {
        Login login = new Login();
        login = (Login) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("Login");
        Evento evento = login.getUsuarioEventoPerfil().getEvento();
        pessoaFisica = pessoaFisicaJuridica.getPessoaFisica();
        pessoaJuridica = pessoaFisicaJuridica.getPessoaJuridica() != null ? pessoaFisicaJuridica.getPessoaJuridica() : new PessoaJuridica();
        Recebimentos tmp = recebimentosDao.findRecebimento(pessoaFisica, evento);
        editCurso = new Boolean(true);
        
        if (pessoaFisica.getCategoria() != null) {
            codCategoria = pessoaFisica.getCategoria().getCodigo();
        }
        
        if (tmp != null) {
            codigoTipoInscricao = tmp.getTipoInscricao().getCodigo();
            if (codigoTipoInscricao != 3) {
                codigoAtividade = tmp.getAtividadeInscricao().getCodigo();
                validadeInscricao.setValor(tmp.getValor());
                setAutorizado(false);
            } else {
                autorizador = tmp.getAutorizador();
                setAutorizado(true);
            }
        }

        if (pessoaFisica.getCidade() != null) {
            codEstado = pessoaFisica.getCidade().getEstado().getCodigo();
            codCidade = pessoaFisica.getCidade().getCodigo();
            inicializarCombo2();
        } else {
            codCidade = 1;
            codEstado = 28;
            inicializarCombo2();
        }
        
        carregarCursos();

        caixa = tmp.getCaixa();
        if (caixa == null) {
            caixa = new Caixa();
            caixa.setCodigo(99999);
        }
        
        bloqueado = false;
        return "cadPF";
    }

    public String gravar() {
        if (codigoTipoInscricao.intValue() != 3 && (validadeInscricao.getValor() <= 0 || validadeInscricao.getValor() == null)) {
            FacesContext.getCurrentInstance().addMessage("form",
                    new FacesMessage("Valor da inscricao invalido."));
            return null;
        }
        
        ValidadeInscricao validade = null;
        String navegacao = null;
        Imprimir imprimir = new Imprimir();
        Etiqueta etiqueta = new Etiqueta();
        Cidade cidade = new Cidade();
        Categoria categoria = new Categoria();
        TipoInscricao tipoInscricao = new TipoInscricao();
        AtividadeInscricao atv = new AtividadeInscricao();
        Evento evento = new Evento();
        UsuarioImpressora usuarioImpressora = new UsuarioImpressora();
       
        try {
            
            Login login = new Login();
            login = (Login) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("Login");
            usuarioImpressora = usuarioImpressoraDao.findUsuarioImpressora(login.getUsuarioEventoPerfil().getUsuario().getCodigo());
            evento = login.getUsuarioEventoPerfil().getEvento();
            pessoaFisica.setUsuarioInclusao(login.getUsuarioEventoPerfil().getUsuario().getNome());
            pessoaFisica.setDataInclusao(new Date());
           
            if (pessoaFisica.getCodigo() == null) {
                pessoaFisica.setCidade(cidade);

                cidade = cidadeDao.findByPk(codCidade);
                if (codCategoria != null) {
                    categoria = categoriaDao.findByPk(codCategoria);
                    pessoaFisica.setCategoria(categoria);
                }

                pessoaFisica.setCidade(cidade);
                tipoInscricao = tipoInscricaoDao.findByPk(codigoTipoInscricao);

                if (codigoTipoInscricao != 3) {
                    atv = atividadeInscricaoDao.findByPk(codigoAtividade);
                    //validade = validadeInscricaoDao.findByPk(codigoValidadeAtividade);
                }

                //if (Valida.validaCPF(pessoaFisica.getCpf())) {

                pessoaFisicaDao.inserir(pessoaFisica);
                pessoaFisicaJuridica.setPessoaFisicaJuridicaEventoPK(new PessoaFisicaJuridicaEventoPK(pessoaFisica.getCodigo(), evento.getCodigo()));
                pessoaFisicaJuridica.setPessoaFisica(pessoaFisica);
                pessoaFisicaJuridica.setEvento(evento);
                pessoaFisicaJuridica.setUsuarioInclusao(login.getUsuarioEventoPerfil().getUsuario().getNome());
                pessoaFisicaJuridica.setDataInclusao(new Date());
                pessoaFisicaJuridica.setNumeroParticipacoes(numeroParticipacoes);
                pessoaFisicaJuridicaEventoDao.inserir(pessoaFisicaJuridica);

                recebimentos = new Recebimentos();
                recebimentos.setTipoInscricao(tipoInscricao);
                recebimentos.setDataInclusao(new Date());
                recebimentos.setAtividadeInscricao(atv);


                if (tipoInscricao.getNome().equals("PAGO")) {
                    recebimentos.setDataPagamento(new Date());
                    recebimentos.setStatus("P");
                    recebimentos.setValor(validadeInscricao.getValor());
                } else if (tipoInscricao.getNome().equals("CORTESIA")) {
                    recebimentos.setStatus("P");
                    recebimentos.setValor(0.0);
                    recebimentos.setAutorizador(autorizador);
                    recebimentos.setUsuarioAutorizador(usuarioAutorizador);
                    recebimentos.setAtividadeInscricao(null);
                } else {
                    recebimentos.setStatus("A");
                    recebimentos.setValor(validadeInscricao.getValor());
                }

                recebimentos.setPessoaFisicaJuridicaEvento(pessoaFisicaJuridica);

                if (caixa.getNome() != null) {
                    recebimentos.setCaixa(caixa);
                    caixa.setDisponivel(caixa.getDisponivel() - 1);
                    caixaDao.update(caixa);
                }

                recebimentosDao.insert(recebimentos);
                gravarCursoPessoaFisica();
                etiqueta.setPessoaFisica(pessoaFisica);
                etiqueta.setPessoaJuridica(pessoaFisicaJuridica.getPessoaJuridica());
                etiqueta.setUsuarioInclusao(login.getUsuarioEventoPerfil().getUsuario().getLogin());
                etiqueta.setEvento(evento);
                etiqueta.setTipoEtiqueta(tipoEtiquetaDao.findByPk(1));
                etiquetaDao.inserir(etiqueta);

                FacesContext.getCurrentInstance().addMessage("form",
                        new FacesMessage("Cadastro efetuado com Sucesso!"));
                FacesContext.getCurrentInstance().getExternalContext().getSessionMap().remove("PessoaPFBean");

                if (pessoaFisicaJuridica.getPessoaJuridica() == null) {
                    imprimir.printerS600Part(usuarioImpressora.getImpressora(), etiqueta);
                } else {
                    imprimir.printerS600(usuarioImpressora.getImpressora(), etiqueta);
                }
                return null;
                //} else {
                //  FacesContext.getCurrentInstance().addMessage("form", new FacesMessage("CPF inválido"));
                // return null;
                // }

            } else {
                cidade = cidadeDao.findByPk(codCidade);
                tipoInscricao = tipoInscricaoDao.findByPk(codigoTipoInscricao);
                pessoaFisica.setCidade(cidade);
                pessoaFisica.setUsuarioModificacao(login.getUsuarioEventoPerfil().getUsuario().getNome());
                pessoaFisica.setDataModificacao(new Date());

                pessoaFisicaDao.altera(pessoaFisica);
                recebimentos = recebimentosDao.findRecebimento(pessoaFisica, evento);
                pessoaFisicaJuridica.setUsuarioModificacao(login.getUsuarioEventoPerfil().getUsuario().getNome());
                pessoaFisicaJuridica.setDataModificacao(new Date());
                pessoaFisicaJuridica.setNumeroParticipacoes(numeroParticipacoes);
                pessoaFisicaJuridicaEventoDao.altera(pessoaFisicaJuridica);

                
                if (codigoTipoInscricao != 3) {
                    atv = atividadeInscricaoDao.findByPk(codigoAtividade);
                } else if (validadeInscricao.getValor() == null) {
                    validadeInscricao.setValor(0d);
                }


                if ((codigoTipoInscricao.intValue()) != (recebimentos.getTipoInscricao().getCodigo().intValue()) || recebimentos.getValor().doubleValue() != validadeInscricao.getValor().doubleValue()) {
                    recebimentos.setStatus("C");
                    recebimentos.setDataModificacao(new Date());
                    recebimentosDao.update(recebimentos);

                    recebimentos = new Recebimentos();
                    recebimentos.setTipoInscricao(tipoInscricao);
                    recebimentos.setDataInclusao(new Date());
                    recebimentos.setAtividadeInscricao(atv);
                    
                    if (tipoInscricao.getNome().equals("PAGO")) {
                        recebimentos.setDataPagamento(new Date());
                        recebimentos.setStatus("P");
                        recebimentos.setValor(validadeInscricao.getValor());
                    } else if (tipoInscricao.getNome().equals("CORTESIA")) {
                        recebimentos.setStatus("P");
                        recebimentos.setValor(0.0);
                        recebimentos.setAutorizador(autorizador);
                        recebimentos.setUsuarioAutorizador(usuarioAutorizador);
                        recebimentos.setAtividadeInscricao(null);
                    } else {
                        recebimentos.setStatus("A");
                        recebimentos.setValor(validadeInscricao.getValor());
                    }
                    //pessoaFisicaJuridicaEvento = new PessoaFisicaJuridicaEvento(pessoaFisica.getCodigo(), evento.getCodigo());


                    recebimentos.setPessoaFisicaJuridicaEvento(pessoaFisicaJuridica);
                    recebimentosDao.insert(recebimentos);

                }
                etiqueta.setPessoaJuridica(pessoaFisicaJuridica.getPessoaJuridica());

                etiqueta.setPessoaFisica(pessoaFisica);
                etiqueta.setEvento(evento);
                etiqueta.setUsuarioInclusao(login.getUsuarioEventoPerfil().getUsuario().getLogin());
                etiqueta.setTipoEtiqueta(tipoEtiquetaDao.findByPk(1));
                etiquetaDao.removerEtiqueta(pessoaFisica, evento);
                etiquetaDao.inserir(etiqueta);
                gravarCursoPessoaFisica();
                FacesContext.getCurrentInstance().addMessage("form",
                        new FacesMessage("Alteração efetuada com Sucesso!"));
                FacesContext.getCurrentInstance().getExternalContext().getSessionMap().remove("PessoaPFBean");
                if (pessoaFisicaJuridica.getPessoaJuridica() == null) {
                    imprimir.printerS600Part(usuarioImpressora.getImpressora(), etiqueta);

                } else {
                    imprimir.printerS600(usuarioImpressora.getImpressora(), etiqueta);
                }

                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    public String verificaCPF() {

        Evento evento = new Evento();
        Login login = new Login();
        login = (Login) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("Login");
        evento = login.getUsuarioEventoPerfil().getEvento();
        if (pessoaFisicaDao.findPFCpfExist(pessoaFisica.getCpf(), evento.getCodigo())) {
            System.out.println("passei por aqui!!");
            FacesContext.getCurrentInstance().addMessage("form",
                    new FacesMessage("CPF ja cadastrado!"));
            return null;
        }
        return null;
    }

    public String gravarCursoPessoaFisica() {

        Etiqueta etiqueta;
        UsuarioImpressora usuarioImpressora = new UsuarioImpressora();
        Imprimir imprimir = new Imprimir();
        Login login = new Login();
        login = (Login) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("Login");
        Evento evento = login.getUsuarioEventoPerfil().getEvento();
        usuarioImpressora = usuarioImpressoraDao.findUsuarioImpressora(login.getUsuarioEventoPerfil().getUsuario().getCodigo());

        cursosPessoaFisicaDao.removeAllCursosPessoaFisica(pessoaFisica, evento);
        if (listaStringI != null) {

            for (String cursosLista : listaStringI) {
                cursosPessoaFisica = new CursosPessoaFisica();
                etiqueta = new Etiqueta();
                CursosEvento cursos = cursoDao.getCursoEvento(Integer.valueOf(cursosLista), evento);
                cursosPessoaFisica.setCursosPessoaFisicaPK(new CursosPessoaFisicaPK(pessoaFisica.getCodigo(), cursos.getCursos().getCodigo(), evento.getCodigo()));
                cursosPessoaFisica.setPessoaFisica(pessoaFisica);
                cursosPessoaFisica.setCursosEvento(cursos);
                cursosPessoaFisicaDao.inserir(cursosPessoaFisica);
                etiqueta.setPessoaFisica(pessoaFisica);
                etiqueta.setEvento(evento);
                etiqueta.setUsuarioInclusao(login.getUsuarioEventoPerfil().getUsuario().getLogin());
                etiqueta.setTipoEtiqueta(tipoEtiquetaDao.findByPk(2));
                etiquetaDao.inserir(etiqueta);
                try {
                    imprimir.printerS600PartCursoIEmpresa(etiqueta, usuarioImpressora.getImpressora(), "", cursosPessoaFisica.getCursosEvento().getCursos().getNome(), cursos.getData());
                } catch (Exception e) {

                    e.printStackTrace();
                }
            }

        }

        if (listaStringII != null) {

            for (String cursosLista : listaStringII) {
                cursosPessoaFisica = new CursosPessoaFisica();
                etiqueta = new Etiqueta();
                CursosEvento cursos = cursoDao.getCursoEvento(Integer.valueOf(cursosLista), evento);
                cursosPessoaFisica.setCursosPessoaFisicaPK(new CursosPessoaFisicaPK(pessoaFisica.getCodigo(), cursos.getCursos().getCodigo(), evento.getCodigo()));
                cursosPessoaFisica.setPessoaFisica(pessoaFisica);
                cursosPessoaFisica.setCursosEvento(cursos);
                cursosPessoaFisicaDao.inserir(cursosPessoaFisica);
                etiqueta.setPessoaFisica(pessoaFisica);
                etiqueta.setEvento(evento);
                etiqueta.setUsuarioInclusao(login.getUsuarioEventoPerfil().getUsuario().getLogin());
                etiqueta.setTipoEtiqueta(tipoEtiquetaDao.findByPk(2));
                etiquetaDao.inserir(etiqueta);
                try {
                    imprimir.printerS600PartCursoII(etiqueta, usuarioImpressora.getImpressora(), cursosPessoaFisica.getCursosEvento().getCursos().getNome(), cursos.getData());
                } catch (Exception e) {

                    e.printStackTrace();
                }
            }
        }
        editCurso = false;
        return null;
    }

    public String remover() {
        etiquetaDao.removePessoa(pessoaFisica.getCodigo());
        pessoaFisicaJuridicaEventoDao.removePessoaId(pessoaFisica.getCodigo());
        //cursosPessoaFisicaDao.removeAllCursosPessoaFisica(pessoaFisica.getCodigo());
        pessoaFisicaDao.remove(pessoaFisica.getCodigo());

        pesquisaPF();

        return null;
    }

    public String reImprimirPF() {
        Evento evento = new Evento();
        Login login = new Login();
        UsuarioImpressora usuarioImpressora = new UsuarioImpressora();
        Imprimir imprimir = new Imprimir();
        Etiqueta etiqueta = new Etiqueta();
        PessoaFisica pf2 = new PessoaFisica();
        login = (Login) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("Login");
        evento = login.getUsuarioEventoPerfil().getEvento();

        pf2 = pessoaFisicaDao.findByPk(pessoaFisica.getCodigo());
        PessoaFisicaJuridicaEvento tmp = (PessoaFisicaJuridicaEvento) pessoaFisicaJuridicaEventoDao.findByPk(PessoaFisicaJuridicaEvento.class,
                new PessoaFisicaJuridicaEventoPK(pf2.getCodigo(), evento.getCodigo()));
        usuarioImpressora = usuarioImpressoraDao.findUsuarioImpressora(login.getUsuarioEventoPerfil().getUsuario().getCodigo());
        etiqueta.setPessoaFisica(pf2);
        etiqueta.setEvento(evento);
        etiqueta.setPessoaJuridica(tmp.getPessoaJuridica());
        etiqueta.setUsuarioInclusao(login.getUsuarioEventoPerfil().getUsuario().getLogin());
        try {
            if (tmp.getPessoaJuridica() == null) {
                imprimir.printerS600Part(usuarioImpressora.getImpressora(), etiqueta);
            } else {
                imprimir.printerS600(usuarioImpressora.getImpressora(), etiqueta);
            }

        } catch (IOException ex) {
            Logger.getLogger(PessoaPFBean.class.getName()).log(Level.SEVERE, null, ex);
        }
        return null;
    }

    public String habilitarAutorizado() {
        if (codigoTipoInscricao == 3) {
            setAutorizado(true);
            setHabilitaPagamento(false);
        } else {
            setAutorizado(false);
            setHabilitaPagamento(true);
        }

        return null;
    }

    private void carregarCursos() {
        List<String> cursosSelecionadosI = new ArrayList<String>();
        List<String> cursosSelecionadosII = new ArrayList<String>();

        Login login = new Login();
        login = (Login) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("Login");
        Evento evento = login.getUsuarioEventoPerfil().getEvento();

        listarCursosI = new ArrayList<SelectItem>();
        SimpleDateFormat formatI = new SimpleDateFormat("dd/MM/yyyy");
        String dataI = "11/10/2011";
        Date dataCursoI = null;
        try {
            dataCursoI = formatI.parse(dataI);
        } catch (Exception e) {
            e.printStackTrace();
        }
        List<CursosEvento> lista = cursoDao.findALLDataCurso(dataCursoI, evento);

        for (Iterator it = lista.iterator(); it.hasNext();) {
            CursosEvento cursosEvento = (CursosEvento) it.next();
            SelectItem item = new SelectItem();
            if (cursosPessoaFisicaDao.qtdPessoaCurso(cursosEvento.getCursos().getCodigo(), dataCursoI, evento) >= cursosEvento.getCapacidade()) {
                item.setDisabled(true);
                item.setLabel(cursosEvento.getCursos().getNome() + " (ESGOTADO) ");

            } else {
                item.setLabel(cursosEvento.getCursos().getNome());
            }

            item.setValue(cursosEvento.getCursos().getCodigo());

            if (editCurso && cursosPessoaFisicaDao.verificaPessoCurso(pessoaFisica, cursosEvento.getCursos(), evento)) {
                cursosSelecionadosI.add((String) String.valueOf(cursosEvento.getCursos().getCodigo()));
                item.setDisabled(false);
            }

            listarCursosI.add(item);
        }

        // cursos II
        listarCursosII = new ArrayList<SelectItem>();

        formatI = new SimpleDateFormat("dd/MM/yyyy");
        dataI = "12/10/2011";
        dataCursoI = null;
        try {
            dataCursoI = formatI.parse(dataI);
        } catch (Exception e) {
            e.printStackTrace();
        }
        lista = cursoDao.findALLDataCurso(dataCursoI, evento);

        for (Iterator it = lista.iterator(); it.hasNext();) {
            CursosEvento cursosEvento = (CursosEvento) it.next();
            SelectItem item = new SelectItem();
            if (cursosPessoaFisicaDao.qtdPessoaCurso(cursosEvento.getCursos().getCodigo(), dataCursoI, evento) >= cursosEvento.getCapacidade()) {
                item.setDisabled(true);
                item.setLabel(cursosEvento.getCursos().getNome() + " (ESGOTADO) ");
            } else {
                item.setLabel(cursosEvento.getCursos().getNome());
            }

            item.setValue(cursosEvento.getCursos().getCodigo());

            if (editCurso && cursosPessoaFisicaDao.verificaPessoCurso(pessoaFisica, cursosEvento.getCursos(), evento)) {
                cursosSelecionadosII.add((String) String.valueOf(cursosEvento.getCursos().getCodigo()));
                item.setDisabled(false);
            }

            listarCursosII.add(item);
        }
        if (editCurso) {

            listaStringI = new String[cursosSelecionadosI.size()];
            for (int i = 0; i < cursosSelecionadosI.size(); i++) {
                listaStringI[i] = cursosSelecionadosI.get(i);
            }

            listaStringII = new String[cursosSelecionadosII.size()];
            for (int i = 0; i < cursosSelecionadosII.size(); i++) {
                listaStringII[i] = cursosSelecionadosII.get(i);
            }

        }
    }

    public String sessionOut() {
        FacesContext.getCurrentInstance().getExternalContext().getSessionMap().remove("PessoaPFBean");
        carregarCursos();
        return "cadPF";
    }

    public String sessionOutList() {
        FacesContext.getCurrentInstance().getExternalContext().getSessionMap().remove("PessoaPFBean");
        return "consultaPF";
    }

    public String vincularEmpresa() {
        Evento evento = new Evento();
        Login login = new Login();
        login = (Login) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("Login");
        evento = login.getUsuarioEventoPerfil().getEvento();
        PessoaFisicaJuridicaEventoPK pfj = new PessoaFisicaJuridicaEventoPK(pessoaFisica.getCodigo(), evento.getCodigo());
        PessoaFisicaJuridicaEvento pessoaFisicaJuridica = null;
        pessoaFisicaJuridica = (PessoaFisicaJuridicaEvento) pessoaFisicaJuridicaEventoDao.findByPk(PessoaFisicaJuridicaEvento.class, pfj);
        if (pessoaFisicaJuridica.getPessoaJuridica() != null) {
            FacesContext.getCurrentInstance().addMessage("form",
                    new FacesMessage("Participante ja vinculado a empresa."));
            return null;
        }
        editar();
        return "vinculoPFPJ";
    }

    public String enviarVinculoEmpresa() {
        //pessoaJuridica = pessoaJuridicaDao.findByPk(pessoaJuridica.getCodigo());
        pessoaFisicaJuridica.setPessoaJuridica(pessoaJuridica);
        return null;
    }

    public String gravarVinculoEmpresa() {
        if (codigoTipoInscricao != 3 && codigoValidadeAtividade == 0) {
            FacesContext.getCurrentInstance().addMessage("form",
                    new FacesMessage("Valor da inscricao invalido."));
            return null;
        }
        TipoInscricao tipoInscricao = null;
        AtividadeInscricao atv = null;
        ValidadeInscricao validade = null;
        Evento evento = null;
        Login login = null;
        PessoaFisicaJuridicaEvento pessoaFisicaJuridicaEvento = null;

        pessoaFisica = pessoaFisicaDao.findByPk(pessoaFisica.getCodigo());

        login = (Login) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("Login");
        evento = login.getUsuarioEventoPerfil().getEvento();


        tipoInscricao = tipoInscricaoDao.findByPk(codigoTipoInscricao);

        if (codigoTipoInscricao != 3) {
            atv = atividadeInscricaoDao.findByPk(codigoAtividade);
            validade = validadeInscricaoDao.findByPk(codigoValidadeAtividade);
        }

        pessoaFisicaDao.update(pessoaFisica);
        pessoaFisicaJuridicaEvento = (PessoaFisicaJuridicaEvento) pessoaFisicaJuridicaEventoDao.findByPk(PessoaFisicaJuridicaEvento.class, new PessoaFisicaJuridicaEvento(pessoaFisica.getCodigo(), evento.getCodigo()).getPessoaFisicaJuridicaEventoPK());
        pessoaFisicaJuridicaEvento.setPessoaJuridica(pessoaJuridica);
        pessoaFisicaJuridicaEvento.setUsuarioInclusao(login.getUsuario().getNome());
        pessoaFisicaJuridicaEventoDao.inserir(pessoaFisicaJuridicaEvento);

        recebimentos = new Recebimentos();
        recebimentos.setTipoInscricao(tipoInscricao);
        recebimentos.setDataInclusao(new Date());
        recebimentos.setAtividadeInscricao(atv);

        if (tipoInscricao.getNome().equals("PAGO")) {
            recebimentos.setDataPagamento(new Date());
            recebimentos.setStatus("P");
            recebimentos.setValor(validade.getValor());
        } else if (tipoInscricao.getNome().equals("CORTESIA")) {
            recebimentos.setStatus("P");
            recebimentos.setValor(0.0);
            recebimentos.setAtividadeInscricao(null);
        } else {
            recebimentos.setStatus("A");
            recebimentos.setValor(validade.getValor());
        }
        recebimentos.setPessoaFisicaJuridicaEvento(pessoaFisicaJuridicaEvento);
        recebimentosDao.insert(recebimentos);
        FacesContext.getCurrentInstance().getExternalContext().getSessionMap().remove("PessoaPFBean");
        FacesContext.getCurrentInstance().addMessage("form",
                new FacesMessage("Vinculo efetuado com sucesso."));
        return "consultaPF";
    }

    public String concluir() {
        return "listPF";
    }

    public String limpar() {
        pessoaFisica = new PessoaFisica();
        return null;
    }

    public String removeVinculoPFPJ() {
        pessoaJuridica = null;
        pessoaFisicaJuridica.setPessoaJuridica(null);
        return null;
    }

    public String excluir() {
        Login login = new Login();
        login = (Login) FacesContext.getCurrentInstance().getExternalContext().getSessionMap().get("Login");
        Evento evento = new Evento();
        evento = login.getUsuarioEventoPerfil().getEvento();
        PessoaFisicaJuridicaEvento pfj = new PessoaFisicaJuridicaEvento(pessoaFisica.getCodigo(), evento.getCodigo());
        recebimentos = recebimentosDao.findRecebimento(pessoaFisica, evento);
        recebimentosDao.delete(recebimentos.getCodigo(), Recebimentos.class);
        pfj = (PessoaFisicaJuridicaEvento) pessoaFisicaJuridicaEventoDao.findByPk(PessoaFisicaJuridicaEvento.class, pfj.getPessoaFisicaJuridicaEventoPK());
        carregarCursos();
        cursosPessoaFisicaDao.deleteDinamic("CursosPessoaFisica c", " where c.cursosPessoaFisicaPK.pessoaFisicaCodigo=" + pfj.getPessoaFisica().getCodigo()
                + " and c.cursosPessoaFisicaPK.evento=" + evento.getCodigo());
        pessoaFisicaJuridicaEventoDao.delete(pfj.getPessoaFisicaJuridicaEventoPK(), PessoaFisicaJuridicaEvento.class);

        FacesContext.getCurrentInstance().getExternalContext().getSessionMap().remove("PessoaPFBean");
        FacesContext.getCurrentInstance().addMessage("form",
                new FacesMessage("Participante excluido"));

        return "listPF";

    }

    public boolean isBloqueado() {
        return bloqueado;
    }

    public void setBloqueado(boolean bloqueado) {
        this.bloqueado = bloqueado;
    }

    public Caixa getCaixa() {
        return caixa;
    }

    public void setCaixa(Caixa caixa) {
        this.caixa = caixa;
    }

    public String validarRecibo() {
        codigoTipoInscricao = 0;
        if (caixa.getCodigo() == 99999) {
            bloqueado = false;
            solicitaAutorizacao = true;
            return null;
        } else if (caixa.getCodigo() == 99907) {
            solicitaAutorizacao = false;
            bloqueado = false;
            return null;
        }

        caixa = caixaDao.findByPk(caixa.getCodigo());


        if (caixa == null || caixa.getDisponivel() == null) {
            FacesContext.getCurrentInstance().addMessage("", new FacesMessage("Recibo não encontrado."));
            caixa = new Caixa();
            bloqueado = true;
            codigoAtividade = 0;
            codigoTipoInscricao = 0;
            validadeInscricao.setValor(0d);
            return null;
        } else if (caixa.getDisponivel() == 0 || caixa.getStatus().equals("CANCELADO")) {
            FacesContext.getCurrentInstance().addMessage("", new FacesMessage("Recibo já esgotado."));
            caixa = new Caixa();
            bloqueado = true;
            codigoAtividade = 0;
            codigoTipoInscricao = 0;
            validadeInscricao.setValor(0d);
            return null;
        }
        codigoAtividade = caixa.getAtividadeInscricao().getCodigo();

        validadeInscricao.setValor(caixa.getTotal() / caixa.getQuantidade());
        codigoTipoInscricao = 1;
        bloqueado = false;
        return null;
    }

    public String autorizaCortesia() {
        Usuario usuario = usuarioDao.autenticarUsuario(usuarioCortesia, senhaCortesia);
        UsuarioEventoPerfil usuarioEventoPerfil = null;
        autorizacaoCortesia = false;

        if (usuario != null) {
            usuarioEventoPerfil = usuarioEventoPerfilDao.findAllUsuarioEventoPerfil(usuario.getCodigo());
        }

        if (usuarioEventoPerfil != null && usuarioEventoPerfil.getPerfil().getCodigo() == 1) {
            autorizacaoCortesia = true;
            usuarioAutorizador = usuario;
            usuarioCortesia = "";
            senhaCortesia = "";
        } else {
            FacesContext.getCurrentInstance().addMessage("", new FacesMessage("Não autorizado"));

        }

        return null;
    }

    public String getSenhaCortesia() {
        return senhaCortesia;
    }

    public void setSenhaCortesia(String senhaCortesia) {
        this.senhaCortesia = senhaCortesia;
    }

    public boolean isAutorizacaoCortesia() {
        return autorizacaoCortesia;
    }

    public void setAutorizacaoCortesia(boolean autorizacaoCortesia) {
        this.autorizacaoCortesia = autorizacaoCortesia;
    }

    public String getUsuarioCortesia() {
        return usuarioCortesia;
    }

    public void setUsuarioCortesia(String usuarioCortesia) {
        this.usuarioCortesia = usuarioCortesia;
    }
}
